import numpy as np
import matplotlib.pyplot as plt
import wave as w
import os
import struct

# apre il file originale
originale=w.open("file.wav",mode='r')
# scrive i parametri sullo schermo
print("Channels",originale.getnchannels())
print("Sample width",originale.getsampwidth())
print("Framerate",originale.getframerate())
OriginaleFrames=originale.getnframes()
print("Frames",OriginaleFrames)











##FIR filter designed with
##http://t-filter.appspot.com
##
##sampling frequency: 44100 Hz
##
##fixed point precision: 16 bits
##
##* 0 Hz - 10000 Hz
##  gain = 1
##  desired ripple = 1 dB
##  actual ripple = n/a
##
##* 11025 Hz - 22050 Hz
##  gain = 0
##  desired attenuation = -80 dB
##  actual attenuation = n/a

FILTER05_TAP_NUM=117

filter05_taps = [  -20,
  -52,
  -38,
  86,
  259,
  305,
  145,
  -59,
  -77,
  61,
  111,
  -15,
  -106,
  -6,
  111,
  33,
  -111,
  -61,
  109,
  93,
  -100,
  -126,
  83,
  159,
  -57,
  -192,
  21,
  221,
  25,
  -243,
  -82,
  256,
  149,
  -257,
  -225,
  242,
  308,
  -208,
  -398,
  152,
  490,
  -69,
  -582,
  -47,
  673,
  202,
  -759,
  -412,
  838,
  699,
  -906,
  -1119,
  961,
  1814,
  -1002,
  -3311,
  1027,
  10374,
  15348,
  10374,
  1027,
  -3311,
  -1002,
  1814,
  961,
  -1119,
  -906,
  699,
  838,
  -412,
  -759,
  202,
  673,
  -47,
  -582,
  -69,
  490,
  152,
  -398,
  -208,
  308,
  242,
  -225,
  -257,
  149,
  256,
  -82,
  -243,
  25,
  221,
  21,
  -192,
  -57,
  159,
  83,
  -126,
  -100,
  93,
  109,
  -61,
  -111,
  33,
  111,
  -6,
  -106,
  -15,
  111,
  61,
  -77,
  -59,
  145,
  305,
  259,
  86,
  -38,
  -52,
  -20]


##FIR filter designed with
##http://t-filter.appspot.com
##
##sampling frequency: 44100 Hz
##
##fixed point precision: 16 bits
##
##* 0 Hz - 5000 Hz
##  gain = 1
##  desired ripple = 1 dB
##  actual ripple = n/a
##
##* 5512 Hz - 22050 Hz
##  gain = 0
##  desired attenuation = -80 dB
##  actual attenuation = n/a



FILTER025_TAP_NUM=233
filter025_taps= [
  -4,
  -7,
  -7,
  -2,
  14,
  41,
  78,
  116,
  146,
  157,
  141,
  99,
  41,
  -17,
  -58,
  -70,
  -51,
  -12,
  30,
  56,
  55,
  28,
  -11,
  -45,
  -56,
  -39,
  -3,
  36,
  57,
  49,
  16,
  -27,
  -57,
  -59,
  -30,
  15,
  55,
  68,
  46,
  -1,
  -51,
  -76,
  -63,
  -16,
  42,
  81,
  80,
  36,
  -29,
  -83,
  -96,
  -59,
  12,
  80,
  110,
  84,
  11,
  -72,
  -122,
  -111,
  -40,
  56,
  128,
  137,
  73,
  -33,
  -129,
  -162,
  -112,
  2,
  122,
  185,
  153,
  38,
  -105,
  -202,
  -198,
  -88,
  77,
  213,
  245,
  148,
  -36,
  -214,
  -291,
  -218,
  -22,
  202,
  337,
  301,
  100,
  -174,
  -380,
  -400,
  -205,
  123,
  420,
  521,
  349,
  -37,
  -454,
  -678,
  -559,
  -108,
  482,
  910,
  906,
  380,
  -502,
  -1343,
  -1655,
  -1063,
  515,
  2794,
  5187,
  6998,
  7673,
  6998,
  5187,
  2794,
  515,
  -1063,
  -1655,
  -1343,
  -502,
  380,
  906,
  910,
  482,
  -108,
  -559,
  -678,
  -454,
  -37,
  349,
  521,
  420,
  123,
  -205,
  -400,
  -380,
  -174,
  100,
  301,
  337,
  202,
  -22,
  -218,
  -291,
  -214,
  -36,
  148,
  245,
  213,
  77,
  -88,
  -198,
  -202,
  -105,
  38,
  153,
  185,
  122,
  2,
  -112,
  -162,
  -129,
  -33,
  73,
  137,
  128,
  56,
  -40,
  -111,
  -122,
  -72,
  11,
  84,
  110,
  80,
  12,
  -59,
  -96,
  -83,
  -29,
  36,
  80,
  81,
  42,
  -16,
  -63,
  -76,
  -51,
  -1,
  46,
  68,
  55,
  15,
  -30,
  -59,
  -57,
  -27,
  16,
  49,
  57,
  36,
  -3,
  -39,
  -56,
  -45,
  -11,
  28,
  55,
  56,
  30,
  -12,
  -51,
  -70,
  -58,
  -17,
  41,
  99,
  141,
  157,
  146,
  116,
  78,
  41,
  14,
  -2,
  -7,
  -7,
  -4]




##FIR filter designed with
##http://t-filter.appspot.com
##
##sampling frequency: 44100 Hz
##
##fixed point precision: 16 bits
##
##* 0 Hz - 2500 Hz
##  gain = 1
##  desired ripple = 1 dB
##  actual ripple = n/a
##
##* 2756 Hz - 22050 Hz
##  gain = 0
##  desired attenuation = -80 dB
##  actual attenuation = n/a



FILTER0125_TAP_NUM=465

filter0125_taps = [
  -3,
  -2,
  -3,
  -3,
  -3,
  -2,
  0,
  4,
  8,
  15,
  22,
  31,
  40,
  50,
  59,
  68,
  74,
  78,
  78,
  76,
  70,
  60,
  48,
  34,
  19,
  4,
  -10,
  -22,
  -30,
  -35,
  -36,
  -33,
  -26,
  -17,
  -6,
  5,
  15,
  23,
  28,
  30,
  28,
  22,
  14,
  4,
  -6,
  -15,
  -23,
  -27,
  -28,
  -26,
  -20,
  -11,
  -1,
  9,
  18,
  25,
  29,
  28,
  25,
  18,
  8,
  -3,
  -13,
  -22,
  -29,
  -31,
  -30,
  -24,
  -15,
  -4,
  8,
  19,
  28,
  33,
  34,
  31,
  23,
  12,
  -1,
  -14,
  -25,
  -34,
  -38,
  -37,
  -31,
  -21,
  -8,
  7,
  21,
  33,
  41,
  43,
  40,
  31,
  18,
  2,
  -15,
  -30,
  -42,
  -48,
  -48,
  -41,
  -29,
  -13,
  6,
  24,
  40,
  51,
  55,
  52,
  42,
  26,
  6,
  -16,
  -36,
  -52,
  -61,
  -62,
  -55,
  -41,
  -20,
  4,
  28,
  49,
  64,
  71,
  69,
  57,
  37,
  11,
  -17,
  -43,
  -65,
  -78,
  -81,
  -74,
  -56,
  -30,
  1,
  33,
  61,
  82,
  92,
  91,
  77,
  52,
  19,
  -17,
  -53,
  -82,
  -101,
  -107,
  -99,
  -77,
  -44,
  -4,
  39,
  77,
  106,
  122,
  122,
  105,
  74,
  31,
  -18,
  -66,
  -107,
  -135,
  -146,
  -137,
  -109,
  -65,
  -11,
  47,
  101,
  144,
  168,
  171,
  151,
  109,
  50,
  -18,
  -87,
  -147,
  -190,
  -209,
  -200,
  -163,
  -102,
  -24,
  62,
  143,
  210,
  251,
  260,
  234,
  174,
  87,
  -19,
  -128,
  -227,
  -301,
  -339,
  -333,
  -279,
  -183,
  -54,
  94,
  241,
  368,
  455,
  486,
  453,
  352,
  190,
  -19,
  -251,
  -479,
  -672,
  -797,
  -827,
  -743,
  -531,
  -194,
  258,
  799,
  1397,
  2010,
  2594,
  3103,
  3499,
  3750,
  3836,
  3750,
  3499,
  3103,
  2594,
  2010,
  1397,
  799,
  258,
  -194,
  -531,
  -743,
  -827,
  -797,
  -672,
  -479,
  -251,
  -19,
  190,
  352,
  453,
  486,
  455,
  368,
  241,
  94,
  -54,
  -183,
  -279,
  -333,
  -339,
  -301,
  -227,
  -128,
  -19,
  87,
  174,
  234,
  260,
  251,
  210,
  143,
  62,
  -24,
  -102,
  -163,
  -200,
  -209,
  -190,
  -147,
  -87,
  -18,
  50,
  109,
  151,
  171,
  168,
  144,
  101,
  47,
  -11,
  -65,
  -109,
  -137,
  -146,
  -135,
  -107,
  -66,
  -18,
  31,
  74,
  105,
  122,
  122,
  106,
  77,
  39,
  -4,
  -44,
  -77,
  -99,
  -107,
  -101,
  -82,
  -53,
  -17,
  19,
  52,
  77,
  91,
  92,
  82,
  61,
  33,
  1,
  -30,
  -56,
  -74,
  -81,
  -78,
  -65,
  -43,
  -17,
  11,
  37,
  57,
  69,
  71,
  64,
  49,
  28,
  4,
  -20,
  -41,
  -55,
  -62,
  -61,
  -52,
  -36,
  -16,
  6,
  26,
  42,
  52,
  55,
  51,
  40,
  24,
  6,
  -13,
  -29,
  -41,
  -48,
  -48,
  -42,
  -30,
  -15,
  2,
  18,
  31,
  40,
  43,
  41,
  33,
  21,
  7,
  -8,
  -21,
  -31,
  -37,
  -38,
  -34,
  -25,
  -14,
  -1,
  12,
  23,
  31,
  34,
  33,
  28,
  19,
  8,
  -4,
  -15,
  -24,
  -30,
  -31,
  -29,
  -22,
  -13,
  -3,
  8,
  18,
  25,
  28,
  29,
  25,
  18,
  9,
  -1,
  -11,
  -20,
  -26,
  -28,
  -27,
  -23,
  -15,
  -6,
  4,
  14,
  22,
  28,
  30,
  28,
  23,
  15,
  5,
  -6,
  -17,
  -26,
  -33,
  -36,
  -35,
  -30,
  -22,
  -10,
  4,
  19,
  34,
  48,
  60,
  70,
  76,
  78,
  78,
  74,
  68,
  59,
  50,
  40,
  31,
  22,
  15,
  8,
  4,
  0,
  -2,
  -3,
  -3,
  -3,
  -2,
  -3]


if (True):
    # downsample 0.5
    print("Downsample 0.5 x")
    # apre il file in scrittura e imposta i parametri
    down05=w.open("down05.wav",mode='w')
    down05.setnchannels(1)
    down05.setsampwidth(2)
    down05.setframerate(44100)

    # crea un buffer contenente zero
    inbuffer= [0] * FILTER05_TAP_NUM
    # carica il buffer in modo che il primo valore contenuto nel file
    # corrisponda alla posizone in centro

    for i in range(int( FILTER05_TAP_NUM/2),FILTER05_TAP_NUM):
        OriginaleData=originale.readframes(1)
        inbuffer[i]=struct.unpack("h", OriginaleData)[0]

    for f in range(int(OriginaleFrames/2)):
        # colvolve il filtro sul buffer in ingresso
        out=0
        for a in range(FILTER05_TAP_NUM):
            out=out+inbuffer[a]*filter05_taps[a]
            #print (a,out,inbuffer[a]*filter_taps[a],inbuffer[a],filter_taps[a])

        #scrive il dato sul file di uscita
        out=out/(256*256)*2
        down05.writeframes(struct.pack('h',int(out)))

        #------------------------------------------------------------------
        
        if (f<200):
            print(f,out)
        #------------------------------------------------------------------



        # scala il contenuto del inbuffer di 2 valori e inserisce 2 nuovi valori (nel caso di downsample 0.5)
        for i in range(2):
            for a in range(FILTER05_TAP_NUM-1):
                inbuffer[a]=inbuffer[a+1]
            # legge un frame dal file, se a' arrivato alla fine riempie il buffer con zero
            if (originale.tell()<OriginaleFrames):
                OriginaleData=originale.readframes(1)
                inbuffer[FILTER05_TAP_NUM-1]=struct.unpack("h", OriginaleData)[0]
            else:
                inbuffer[FILTER05_TAP_NUM-1]=0


    down05.close()





if (True):

    # upsample 2
    print("Upsample 2 x")
    # apre il file in scrittura e imposta i parametri
    up2=w.open("up2.wav",mode='w')
    up2.setnchannels(1)
    up2.setsampwidth(2)
    up2.setframerate(44100)

    # riporta l'indice nell'originale all'inizio
    originale.rewind()

    # upsample 2 usa lo stesso filtro di downsample 05
    # crea un buffer contenente zero
    inbuffer= [0] * FILTER05_TAP_NUM

    # carica il buffer in modo che il primo valore contenuto nel file
    # corrisponda alla posizone in centro (saltando un valore ogni due)
    i1=0
    for i in range(int( FILTER05_TAP_NUM/2),FILTER05_TAP_NUM):
        # una volta inserisce il valore e una volta lo salta
        if (i1==0):
            OriginaleData=originale.readframes(1)
            inbuffer[i]=struct.unpack("h", OriginaleData)[0]
        i1+=1

        #------------------------------------------------------------------
        #qui e' stato verificato ed e' identico
        #print("inbuffer",i,"valore",inbuffer[i])
        #------------------------------------------------------------------
        
        if (i1>1):
            i1=0

    for f in range(int(OriginaleFrames*2)):
        # colvolve il filtro sul buffer in ingresso
        out=0
        for a in range(FILTER05_TAP_NUM):
            out=out+inbuffer[a]*filter05_taps[a]
            #print (a,inbuffer[a],filter05_taps[a],inbuffer[a]*filter05_taps[a])

        #scrive il dato sul file di uscita
        out=out/(256*256)*2

        #------------------------------------------------------------------
        
        if (f<200):
            print(f,out)
        #------------------------------------------------------------------

        
        up2.writeframes(struct.pack('h',int(out)))

        # scala il contenuto del inbuffer di una posizione
        # una volta si e una no inserisce un nuovo valore (secondo il contatore i1)
        for a in range(FILTER05_TAP_NUM-1):
            inbuffer[a]=inbuffer[a+1]
        if (i1==0):
            # legge un frame dal file, se a' arrivato alla fine riempie il buffer con zero
            if (originale.tell()<OriginaleFrames):
                OriginaleData=originale.readframes(1)
                inbuffer[FILTER05_TAP_NUM-1]=struct.unpack("h", OriginaleData)[0]
            else:
                inbuffer[FILTER05_TAP_NUM-1]=0
        else:
             inbuffer[FILTER05_TAP_NUM-1]=0
        
        i1+=1
        if (i1>1):
            i1=0            


    up2.close()

if (True):
    # downsample 0.25
    print("Downsample 0.25 x")
    # apre il file in scrittura e imposta i parametri
    down025=w.open("down025.wav",mode='w')
    down025.setnchannels(1)
    down025.setsampwidth(2)
    down025.setframerate(44100)
    
    # riporta l'indice dell'originale all'inizio
    originale.rewind()

    # crea un buffer contenente zero
    inbuffer= [0] * FILTER025_TAP_NUM
    # carica il buffer in modo che il primo valore contenuto nel file
    # corrisponda alla posizone in centro

    for i in range(int( FILTER025_TAP_NUM/2),FILTER025_TAP_NUM):
        OriginaleData=originale.readframes(1)
        inbuffer[i]=struct.unpack("h", OriginaleData)[0]

    for f in range(int(OriginaleFrames/4)):
        # colvolve il filtro sul buffer in ingresso
        out=0
        for a in range(FILTER025_TAP_NUM):
            out=out+inbuffer[a]*filter025_taps[a]
            #print (a,out,inbuffer[a]*filter_taps[a],inbuffer[a],filter_taps[a])

        #scrive il dato sul file di uscita
        out=out/(256*256)*2
        down025.writeframes(struct.pack('h',int(out)))

        
        #------------------------------------------------------------------
        if (f<200):
            print(f,out)
        #------------------------------------------------------------------
            
        # scala il contenuto del inbuffer di 4 valori e inserisce 4 nuovi valori (nel caso di downsample 0.25)
        for i in range(4):
            for a in range(FILTER025_TAP_NUM-1):
                inbuffer[a]=inbuffer[a+1]
            # legge un frame dal file, se a' arrivato alla fine riempie il buffer con zero
            if (originale.tell()<OriginaleFrames):
                OriginaleData=originale.readframes(1)
                inbuffer[FILTER025_TAP_NUM-1]=struct.unpack("h", OriginaleData)[0]
            else:
                inbuffer[FILTER025_TAP_NUM-1]=0


    down025.close()




if (True):

    # upsample 4
    print("Upsample 4 x")
    # apre il file in scrittura e imposta i parametri
    up4=w.open("up4.wav",mode='w')
    up4.setnchannels(1)
    up4.setsampwidth(2)
    up4.setframerate(44100)

    # riporta l'indice nell'originale all'inizio
    originale.rewind()

    # upsample 4 usa lo stesso filtro di downsample 025
    # crea un buffer contenente zero
    inbuffer= [0] * FILTER025_TAP_NUM

    # carica il buffer in modo che il primo valore contenuto nel file
    # corrisponda alla posizone in centro (saltando un valore ogni due)
    i1=0
    for i in range(int( FILTER025_TAP_NUM/2),FILTER025_TAP_NUM):
        # una volta inserisce il valore e una volta lo salta
        if (i1==0):
            OriginaleData=originale.readframes(1)
            inbuffer[i]=struct.unpack("h", OriginaleData)[0]
        i1+=1
        if (i1>3):
            i1=0
  

    for f in range(int(OriginaleFrames*4)):
        # colvolve il filtro sul buffer in ingresso
        out=0
        for a in range(FILTER025_TAP_NUM):
            
            out=out+inbuffer[a]*filter025_taps[a]
            #print (a,out,inbuffer[a]*filter025_taps[a],inbuffer[a],filter025_taps[a])
           

        #scrive il dato sul file di uscita
        out=out/(256*256)*8
        #print("out",out)
        up4.writeframes(struct.pack('h',int(out)))

        # scala il contenuto del inbuffer di una posizione
        # una volta si e tre no inserisce un nuovo valore (secondo il contatore i1)
        for a in range(FILTER025_TAP_NUM-1):
            inbuffer[a]=inbuffer[a+1]
        if (i1==0):
            # legge un frame dal file, se a' arrivato alla fine riempie il buffer con zero
            if (originale.tell()<OriginaleFrames):
                OriginaleData=originale.readframes(1)
                inbuffer[FILTER025_TAP_NUM-1]=struct.unpack("h", OriginaleData)[0]
            else:
                inbuffer[FILTER025_TAP_NUM-1]=0
        else:
             inbuffer[FILTER025_TAP_NUM-1]=0
        
        i1+=1
        if (i1>3):
            i1=0            


    up4.close()

if (True):
    # downsample 0.125
    print("Downsample 0.125 x")
    # apre il file in scrittura e imposta i parametri
    down0125=w.open("down0125.wav",mode='w')
    down0125.setnchannels(1)
    down0125.setsampwidth(2)
    down0125.setframerate(44100)
    
    # riporta l'indice dell'originale all'inizio
    originale.rewind()

    # crea un buffer contenente zero
    inbuffer= [0] * FILTER0125_TAP_NUM
    # carica il buffer in modo che il primo valore contenuto nel file
    # corrisponda alla posizone in centro

    for i in range(int( FILTER0125_TAP_NUM/2),FILTER0125_TAP_NUM):
        OriginaleData=originale.readframes(1)
        inbuffer[i]=struct.unpack("h", OriginaleData)[0]

    for f in range(int(OriginaleFrames/8)):
        # colvolve il filtro sul buffer in ingresso
        out=0
        for a in range(FILTER0125_TAP_NUM):
            out=out+inbuffer[a]*filter0125_taps[a]
            #print (a,out,inbuffer[a]*filter_taps[a],inbuffer[a],filter_taps[a])

        #scrive il dato sul file di uscita
        out=out/(256*256)*2
        down0125.writeframes(struct.pack('h',int(out)))

        #------------------------------------------------------------------
        if (f<200):
            print(f,out)
        #------------------------------------------------------------------

        # scala il contenuto del inbuffer di 8 valori e inserisce 8 nuovi valori (nel caso di downsample 0.125)
        for i in range(8):
            for a in range(FILTER0125_TAP_NUM-1):
                inbuffer[a]=inbuffer[a+1]
            # legge un frame dal file, se a' arrivato alla fine riempie il buffer con zero
            if (originale.tell()<OriginaleFrames):
                OriginaleData=originale.readframes(1)
                inbuffer[FILTER0125_TAP_NUM-1]=struct.unpack("h", OriginaleData)[0]
            else:
                inbuffer[FILTER0125_TAP_NUM-1]=0
    down0125.close()

if (True):

    # upsample 8
    print("Upsample 8 x")
    # apre il file in scrittura e imposta i parametri
    up8=w.open("up8.wav",mode='w')
    up8.setnchannels(1)
    up8.setsampwidth(2)
    up8.setframerate(44100)

    # riporta l'indice nell'originale all'inizio
    originale.rewind()

    # upsample 8 usa lo stesso filtro di downsample 0125
    # crea un buffer contenente zero
    inbuffer= [0] * FILTER0125_TAP_NUM

    # carica il buffer in modo che il primo valore contenuto nel file
    # corrisponda alla posizone in centro (saltando un valore ogni due)
    i1=0
    for i in range(int( FILTER0125_TAP_NUM/2),FILTER0125_TAP_NUM):
        # una volta inserisce il valore e una volta lo salta
        if (i1==0):
            OriginaleData=originale.readframes(1)
            inbuffer[i]=struct.unpack("h", OriginaleData)[0]
        i1+=1
        if (i1>7):
            i1=0
  

    for f in range(int(OriginaleFrames*8)):
        # colvolve il filtro sul buffer in ingresso
        out=0
        for a in range(FILTER0125_TAP_NUM):
            
            out=out+inbuffer[a]*filter0125_taps[a]
            #print (a,out,inbuffer[a]*filter025_taps[a],inbuffer[a],filter025_taps[a])
           

        #scrive il dato sul file di uscita
        out=out/(256*256)*16
        up8.writeframes(struct.pack('h',int(out)))

        # scala il contenuto del inbuffer di una posizione
        # una volta si e 7 no inserisce un nuovo valore (secondo il contatore i1)
        for a in range(FILTER0125_TAP_NUM-1):
            inbuffer[a]=inbuffer[a+1]
        if (i1==0):
            # legge un frame dal file, se a' arrivato alla fine riempie il buffer con zero
            if (originale.tell()<OriginaleFrames):
                OriginaleData=originale.readframes(1)
                inbuffer[FILTER0125_TAP_NUM-1]=struct.unpack("h", OriginaleData)[0]
            else:
                inbuffer[FILTER0125_TAP_NUM-1]=0
        else:
             inbuffer[FILTER0125_TAP_NUM-1]=0
        
        i1+=1
        if (i1>7):
            i1=0            


    up8.close()


originale.close()